//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Route53RecoveryReadiness service.
///
/// Recovery readiness
public struct Route53RecoveryReadiness: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Route53RecoveryReadiness client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Route53RecoveryReadiness",
            serviceIdentifier: "route53-recovery-readiness",
            serviceProtocol: .restjson,
            apiVersion: "2019-12-02",
            endpoint: endpoint,
            errorType: Route53RecoveryReadinessErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Creates a cell in an account.
    @Sendable
    @inlinable
    public func createCell(_ input: CreateCellRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCellResponse {
        try await self.client.execute(
            operation: "CreateCell", 
            path: "/cells", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a cell in an account.
    ///
    /// Parameters:
    ///   - cellName: The name of the cell to create.
    ///   - cells: A list of cell Amazon Resource Names (ARNs) contained within this cell, for use in nested cells. For example, Availability Zones within specific Amazon Web Services Regions.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createCell(
        cellName: String? = nil,
        cells: [String]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCellResponse {
        let input = CreateCellRequest(
            cellName: cellName, 
            cells: cells, 
            tags: tags
        )
        return try await self.createCell(input, logger: logger)
    }

    /// Creates a cross-account readiness authorization. This lets you authorize another account to work with Route 53 Application Recovery Controller, for example, to check the readiness status of resources in a separate account.
    @Sendable
    @inlinable
    public func createCrossAccountAuthorization(_ input: CreateCrossAccountAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCrossAccountAuthorizationResponse {
        try await self.client.execute(
            operation: "CreateCrossAccountAuthorization", 
            path: "/crossaccountauthorizations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a cross-account readiness authorization. This lets you authorize another account to work with Route 53 Application Recovery Controller, for example, to check the readiness status of resources in a separate account.
    ///
    /// Parameters:
    ///   - crossAccountAuthorization: The cross-account authorization.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCrossAccountAuthorization(
        crossAccountAuthorization: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCrossAccountAuthorizationResponse {
        let input = CreateCrossAccountAuthorizationRequest(
            crossAccountAuthorization: crossAccountAuthorization
        )
        return try await self.createCrossAccountAuthorization(input, logger: logger)
    }

    /// Creates a readiness check in an account. A readiness check monitors a resource set in your application, such as a set of Amazon Aurora instances, that Application Recovery Controller is auditing recovery readiness for. The audits run once every minute on every resource that's associated with a readiness check.
    @Sendable
    @inlinable
    public func createReadinessCheck(_ input: CreateReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReadinessCheckResponse {
        try await self.client.execute(
            operation: "CreateReadinessCheck", 
            path: "/readinesschecks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a readiness check in an account. A readiness check monitors a resource set in your application, such as a set of Amazon Aurora instances, that Application Recovery Controller is auditing recovery readiness for. The audits run once every minute on every resource that's associated with a readiness check.
    ///
    /// Parameters:
    ///   - readinessCheckName: The name of the readiness check to create.
    ///   - resourceSetName: The name of the resource set to check.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createReadinessCheck(
        readinessCheckName: String? = nil,
        resourceSetName: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReadinessCheckResponse {
        let input = CreateReadinessCheckRequest(
            readinessCheckName: readinessCheckName, 
            resourceSetName: resourceSetName, 
            tags: tags
        )
        return try await self.createReadinessCheck(input, logger: logger)
    }

    /// Creates a recovery group in an account. A recovery group corresponds to an application and includes a list of the cells that make up the application.
    @Sendable
    @inlinable
    public func createRecoveryGroup(_ input: CreateRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRecoveryGroupResponse {
        try await self.client.execute(
            operation: "CreateRecoveryGroup", 
            path: "/recoverygroups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a recovery group in an account. A recovery group corresponds to an application and includes a list of the cells that make up the application.
    ///
    /// Parameters:
    ///   - cells: A list of the cell Amazon Resource Names (ARNs) in the recovery group.
    ///   - recoveryGroupName: The name of the recovery group to create.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createRecoveryGroup(
        cells: [String]? = nil,
        recoveryGroupName: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRecoveryGroupResponse {
        let input = CreateRecoveryGroupRequest(
            cells: cells, 
            recoveryGroupName: recoveryGroupName, 
            tags: tags
        )
        return try await self.createRecoveryGroup(input, logger: logger)
    }

    /// Creates a resource set. A resource set is a set of resources of one type that span multiple cells. You can associate a resource set with a readiness check to monitor the resources for failover readiness.
    @Sendable
    @inlinable
    public func createResourceSet(_ input: CreateResourceSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateResourceSetResponse {
        try await self.client.execute(
            operation: "CreateResourceSet", 
            path: "/resourcesets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a resource set. A resource set is a set of resources of one type that span multiple cells. You can associate a resource set with a readiness check to monitor the resources for failover readiness.
    ///
    /// Parameters:
    ///   - resources: A list of resource objects in the resource set.
    ///   - resourceSetName: The name of the resource set to create.
    ///   - resourceSetType: The resource type of the resources in the resource set. Enter one of the following values for resource type: AWS::ApiGateway::Stage, AWS::ApiGatewayV2::Stage, AWS::AutoScaling::AutoScalingGroup, AWS::CloudWatch::Alarm, AWS::EC2::CustomerGateway, AWS::DynamoDB::Table, AWS::EC2::Volume, AWS::ElasticLoadBalancing::LoadBalancer, AWS::ElasticLoadBalancingV2::LoadBalancer, AWS::Lambda::Function, AWS::MSK::Cluster, AWS::RDS::DBCluster, AWS::Route53::HealthCheck, AWS::SQS::Queue, AWS::SNS::Topic, AWS::SNS::Subscription, AWS::EC2::VPC, AWS::EC2::VPNConnection, AWS::EC2::VPNGateway, AWS::Route53RecoveryReadiness::DNSTargetResource
    ///   - tags: A tag to associate with the parameters for a resource set.
    ///   - logger: Logger use during operation
    @inlinable
    public func createResourceSet(
        resources: [Resource]? = nil,
        resourceSetName: String? = nil,
        resourceSetType: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateResourceSetResponse {
        let input = CreateResourceSetRequest(
            resources: resources, 
            resourceSetName: resourceSetName, 
            resourceSetType: resourceSetType, 
            tags: tags
        )
        return try await self.createResourceSet(input, logger: logger)
    }

    /// Delete a cell. When successful, the response code is 204, with no response body.
    @Sendable
    @inlinable
    public func deleteCell(_ input: DeleteCellRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteCell", 
            path: "/cells/{CellName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a cell. When successful, the response code is 204, with no response body.
    ///
    /// Parameters:
    ///   - cellName: The name of the cell.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCell(
        cellName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteCellRequest(
            cellName: cellName
        )
        return try await self.deleteCell(input, logger: logger)
    }

    /// Deletes cross account readiness authorization.
    @Sendable
    @inlinable
    public func deleteCrossAccountAuthorization(_ input: DeleteCrossAccountAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCrossAccountAuthorizationResponse {
        try await self.client.execute(
            operation: "DeleteCrossAccountAuthorization", 
            path: "/crossaccountauthorizations/{CrossAccountAuthorization}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes cross account readiness authorization.
    ///
    /// Parameters:
    ///   - crossAccountAuthorization: The cross-account authorization.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCrossAccountAuthorization(
        crossAccountAuthorization: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCrossAccountAuthorizationResponse {
        let input = DeleteCrossAccountAuthorizationRequest(
            crossAccountAuthorization: crossAccountAuthorization
        )
        return try await self.deleteCrossAccountAuthorization(input, logger: logger)
    }

    /// Deletes a readiness check.
    @Sendable
    @inlinable
    public func deleteReadinessCheck(_ input: DeleteReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteReadinessCheck", 
            path: "/readinesschecks/{ReadinessCheckName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a readiness check.
    ///
    /// Parameters:
    ///   - readinessCheckName: Name of a readiness check.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReadinessCheck(
        readinessCheckName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteReadinessCheckRequest(
            readinessCheckName: readinessCheckName
        )
        return try await self.deleteReadinessCheck(input, logger: logger)
    }

    /// Deletes a recovery group.
    @Sendable
    @inlinable
    public func deleteRecoveryGroup(_ input: DeleteRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRecoveryGroup", 
            path: "/recoverygroups/{RecoveryGroupName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a recovery group.
    ///
    /// Parameters:
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRecoveryGroup(
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRecoveryGroupRequest(
            recoveryGroupName: recoveryGroupName
        )
        return try await self.deleteRecoveryGroup(input, logger: logger)
    }

    /// Deletes a resource set.
    @Sendable
    @inlinable
    public func deleteResourceSet(_ input: DeleteResourceSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteResourceSet", 
            path: "/resourcesets/{ResourceSetName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a resource set.
    ///
    /// Parameters:
    ///   - resourceSetName: Name of a resource set.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourceSet(
        resourceSetName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteResourceSetRequest(
            resourceSetName: resourceSetName
        )
        return try await self.deleteResourceSet(input, logger: logger)
    }

    /// Gets recommendations about architecture designs for improving resiliency for an application, based on a recovery group.
    @Sendable
    @inlinable
    public func getArchitectureRecommendations(_ input: GetArchitectureRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetArchitectureRecommendationsResponse {
        try await self.client.execute(
            operation: "GetArchitectureRecommendations", 
            path: "/recoverygroups/{RecoveryGroupName}/architectureRecommendations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets recommendations about architecture designs for improving resiliency for an application, based on a recovery group.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getArchitectureRecommendations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetArchitectureRecommendationsResponse {
        let input = GetArchitectureRecommendationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            recoveryGroupName: recoveryGroupName
        )
        return try await self.getArchitectureRecommendations(input, logger: logger)
    }

    /// Gets information about a cell including cell name, cell Amazon Resource Name (ARN), ARNs of nested cells for this cell, and a list of those cell ARNs with their associated recovery group ARNs.
    @Sendable
    @inlinable
    public func getCell(_ input: GetCellRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCellResponse {
        try await self.client.execute(
            operation: "GetCell", 
            path: "/cells/{CellName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a cell including cell name, cell Amazon Resource Name (ARN), ARNs of nested cells for this cell, and a list of those cell ARNs with their associated recovery group ARNs.
    ///
    /// Parameters:
    ///   - cellName: The name of the cell.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCell(
        cellName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCellResponse {
        let input = GetCellRequest(
            cellName: cellName
        )
        return try await self.getCell(input, logger: logger)
    }

    /// Gets readiness for a cell. Aggregates the readiness of all the resources that are associated with the cell into a single value.
    @Sendable
    @inlinable
    public func getCellReadinessSummary(_ input: GetCellReadinessSummaryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCellReadinessSummaryResponse {
        try await self.client.execute(
            operation: "GetCellReadinessSummary", 
            path: "/cellreadiness/{CellName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets readiness for a cell. Aggregates the readiness of all the resources that are associated with the cell into a single value.
    ///
    /// Parameters:
    ///   - cellName: The name of the cell.
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCellReadinessSummary(
        cellName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCellReadinessSummaryResponse {
        let input = GetCellReadinessSummaryRequest(
            cellName: cellName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getCellReadinessSummary(input, logger: logger)
    }

    /// Gets details about a readiness check.
    @Sendable
    @inlinable
    public func getReadinessCheck(_ input: GetReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadinessCheckResponse {
        try await self.client.execute(
            operation: "GetReadinessCheck", 
            path: "/readinesschecks/{ReadinessCheckName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a readiness check.
    ///
    /// Parameters:
    ///   - readinessCheckName: Name of a readiness check.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadinessCheck(
        readinessCheckName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadinessCheckResponse {
        let input = GetReadinessCheckRequest(
            readinessCheckName: readinessCheckName
        )
        return try await self.getReadinessCheck(input, logger: logger)
    }

    /// Gets individual readiness status for a readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in the recovery group, use GetRecoveryGroupReadinessSummary.
    @Sendable
    @inlinable
    public func getReadinessCheckResourceStatus(_ input: GetReadinessCheckResourceStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadinessCheckResourceStatusResponse {
        try await self.client.execute(
            operation: "GetReadinessCheckResourceStatus", 
            path: "/readinesschecks/{ReadinessCheckName}/resource/{ResourceIdentifier}/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets individual readiness status for a readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in the recovery group, use GetRecoveryGroupReadinessSummary.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - readinessCheckName: Name of a readiness check.
    ///   - resourceIdentifier: The resource identifier, which is the Amazon Resource Name (ARN) or the identifier generated for the resource by Application Recovery Controller (for example, for a DNS target resource).
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadinessCheckResourceStatus(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        readinessCheckName: String,
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadinessCheckResourceStatusResponse {
        let input = GetReadinessCheckResourceStatusRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            readinessCheckName: readinessCheckName, 
            resourceIdentifier: resourceIdentifier
        )
        return try await self.getReadinessCheckResourceStatus(input, logger: logger)
    }

    /// Gets the readiness status for an individual readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in a recovery group, use GetRecoveryGroupReadinessSummary.
    @Sendable
    @inlinable
    public func getReadinessCheckStatus(_ input: GetReadinessCheckStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReadinessCheckStatusResponse {
        try await self.client.execute(
            operation: "GetReadinessCheckStatus", 
            path: "/readinesschecks/{ReadinessCheckName}/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the readiness status for an individual readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in a recovery group, use GetRecoveryGroupReadinessSummary.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - readinessCheckName: Name of a readiness check.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReadinessCheckStatus(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        readinessCheckName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReadinessCheckStatusResponse {
        let input = GetReadinessCheckStatusRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            readinessCheckName: readinessCheckName
        )
        return try await self.getReadinessCheckStatus(input, logger: logger)
    }

    /// Gets details about a recovery group, including a list of the cells that are included in it.
    @Sendable
    @inlinable
    public func getRecoveryGroup(_ input: GetRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecoveryGroupResponse {
        try await self.client.execute(
            operation: "GetRecoveryGroup", 
            path: "/recoverygroups/{RecoveryGroupName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a recovery group, including a list of the cells that are included in it.
    ///
    /// Parameters:
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRecoveryGroup(
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecoveryGroupResponse {
        let input = GetRecoveryGroupRequest(
            recoveryGroupName: recoveryGroupName
        )
        return try await self.getRecoveryGroup(input, logger: logger)
    }

    /// Displays a summary of information about a recovery group's readiness status. Includes the readiness checks for resources in the recovery group and the readiness status of each one.
    @Sendable
    @inlinable
    public func getRecoveryGroupReadinessSummary(_ input: GetRecoveryGroupReadinessSummaryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecoveryGroupReadinessSummaryResponse {
        try await self.client.execute(
            operation: "GetRecoveryGroupReadinessSummary", 
            path: "/recoverygroupreadiness/{RecoveryGroupName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Displays a summary of information about a recovery group's readiness status. Includes the readiness checks for resources in the recovery group and the readiness status of each one.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRecoveryGroupReadinessSummary(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecoveryGroupReadinessSummaryResponse {
        let input = GetRecoveryGroupReadinessSummaryRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            recoveryGroupName: recoveryGroupName
        )
        return try await self.getRecoveryGroupReadinessSummary(input, logger: logger)
    }

    /// Displays the details about a resource set, including a list of the resources in the set.
    @Sendable
    @inlinable
    public func getResourceSet(_ input: GetResourceSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceSetResponse {
        try await self.client.execute(
            operation: "GetResourceSet", 
            path: "/resourcesets/{ResourceSetName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Displays the details about a resource set, including a list of the resources in the set.
    ///
    /// Parameters:
    ///   - resourceSetName: Name of a resource set.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceSet(
        resourceSetName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceSetResponse {
        let input = GetResourceSetRequest(
            resourceSetName: resourceSetName
        )
        return try await self.getResourceSet(input, logger: logger)
    }

    /// Lists the cells for an account.
    @Sendable
    @inlinable
    public func listCells(_ input: ListCellsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCellsResponse {
        try await self.client.execute(
            operation: "ListCells", 
            path: "/cells", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the cells for an account.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCells(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCellsResponse {
        let input = ListCellsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCells(input, logger: logger)
    }

    /// Lists the cross-account readiness authorizations that are in place for an account.
    @Sendable
    @inlinable
    public func listCrossAccountAuthorizations(_ input: ListCrossAccountAuthorizationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCrossAccountAuthorizationsResponse {
        try await self.client.execute(
            operation: "ListCrossAccountAuthorizations", 
            path: "/crossaccountauthorizations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the cross-account readiness authorizations that are in place for an account.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCrossAccountAuthorizations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCrossAccountAuthorizationsResponse {
        let input = ListCrossAccountAuthorizationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCrossAccountAuthorizations(input, logger: logger)
    }

    /// Lists the readiness checks for an account.
    @Sendable
    @inlinable
    public func listReadinessChecks(_ input: ListReadinessChecksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReadinessChecksResponse {
        try await self.client.execute(
            operation: "ListReadinessChecks", 
            path: "/readinesschecks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the readiness checks for an account.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReadinessChecks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReadinessChecksResponse {
        let input = ListReadinessChecksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReadinessChecks(input, logger: logger)
    }

    /// Lists the recovery groups in an account.
    @Sendable
    @inlinable
    public func listRecoveryGroups(_ input: ListRecoveryGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRecoveryGroupsResponse {
        try await self.client.execute(
            operation: "ListRecoveryGroups", 
            path: "/recoverygroups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the recovery groups in an account.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRecoveryGroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRecoveryGroupsResponse {
        let input = ListRecoveryGroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listRecoveryGroups(input, logger: logger)
    }

    /// Lists the resource sets in an account.
    @Sendable
    @inlinable
    public func listResourceSets(_ input: ListResourceSetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceSetsResponse {
        try await self.client.execute(
            operation: "ListResourceSets", 
            path: "/resourcesets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the resource sets in an account.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceSets(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceSetsResponse {
        let input = ListResourceSetsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listResourceSets(input, logger: logger)
    }

    /// Lists all readiness rules, or lists the readiness rules for a specific resource type.
    @Sendable
    @inlinable
    public func listRules(_ input: ListRulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRulesResponse {
        try await self.client.execute(
            operation: "ListRules", 
            path: "/rules", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all readiness rules, or lists the readiness rules for a specific resource type.
    ///
    /// Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - nextToken: The token that identifies which batch of results you want to see.
    ///   - resourceType: The resource type that a readiness rule applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRules(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRulesResponse {
        let input = ListRulesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.listRules(input, logger: logger)
    }

    /// Lists the tags for a resource.
    @Sendable
    @inlinable
    public func listTagsForResources(_ input: ListTagsForResourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourcesResponse {
        try await self.client.execute(
            operation: "ListTagsForResources", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) for a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResources(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourcesResponse {
        let input = ListTagsForResourcesRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResources(input, logger: logger)
    }

    /// Adds a tag to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a tag to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) for a resource.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) for a resource.
    ///   - tagKeys: The keys for tags you add to resources.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates a cell to replace the list of nested cells with a new list of nested cells.
    @Sendable
    @inlinable
    public func updateCell(_ input: UpdateCellRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCellResponse {
        try await self.client.execute(
            operation: "UpdateCell", 
            path: "/cells/{CellName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a cell to replace the list of nested cells with a new list of nested cells.
    ///
    /// Parameters:
    ///   - cellName: The name of the cell.
    ///   - cells: A list of cell Amazon Resource Names (ARNs), which completely replaces the previous list.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCell(
        cellName: String,
        cells: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCellResponse {
        let input = UpdateCellRequest(
            cellName: cellName, 
            cells: cells
        )
        return try await self.updateCell(input, logger: logger)
    }

    /// Updates a readiness check.
    @Sendable
    @inlinable
    public func updateReadinessCheck(_ input: UpdateReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateReadinessCheckResponse {
        try await self.client.execute(
            operation: "UpdateReadinessCheck", 
            path: "/readinesschecks/{ReadinessCheckName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a readiness check.
    ///
    /// Parameters:
    ///   - readinessCheckName: Name of a readiness check.
    ///   - resourceSetName: The name of the resource set to be checked.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateReadinessCheck(
        readinessCheckName: String,
        resourceSetName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateReadinessCheckResponse {
        let input = UpdateReadinessCheckRequest(
            readinessCheckName: readinessCheckName, 
            resourceSetName: resourceSetName
        )
        return try await self.updateReadinessCheck(input, logger: logger)
    }

    /// Updates a recovery group.
    @Sendable
    @inlinable
    public func updateRecoveryGroup(_ input: UpdateRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRecoveryGroupResponse {
        try await self.client.execute(
            operation: "UpdateRecoveryGroup", 
            path: "/recoverygroups/{RecoveryGroupName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a recovery group.
    ///
    /// Parameters:
    ///   - cells: A list of cell Amazon Resource Names (ARNs). This list completely replaces the previous list.
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRecoveryGroup(
        cells: [String]? = nil,
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRecoveryGroupResponse {
        let input = UpdateRecoveryGroupRequest(
            cells: cells, 
            recoveryGroupName: recoveryGroupName
        )
        return try await self.updateRecoveryGroup(input, logger: logger)
    }

    /// Updates a resource set.
    @Sendable
    @inlinable
    public func updateResourceSet(_ input: UpdateResourceSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceSetResponse {
        try await self.client.execute(
            operation: "UpdateResourceSet", 
            path: "/resourcesets/{ResourceSetName}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a resource set.
    ///
    /// Parameters:
    ///   - resources: A list of resource objects.
    ///   - resourceSetName: Name of a resource set.
    ///   - resourceSetType: The resource type of the resources in the resource set. Enter one of the following values for resource type: AWS::ApiGateway::Stage, AWS::ApiGatewayV2::Stage, AWS::AutoScaling::AutoScalingGroup, AWS::CloudWatch::Alarm, AWS::EC2::CustomerGateway, AWS::DynamoDB::Table, AWS::EC2::Volume, AWS::ElasticLoadBalancing::LoadBalancer, AWS::ElasticLoadBalancingV2::LoadBalancer, AWS::Lambda::Function, AWS::MSK::Cluster, AWS::RDS::DBCluster, AWS::Route53::HealthCheck, AWS::SQS::Queue, AWS::SNS::Topic, AWS::SNS::Subscription, AWS::EC2::VPC, AWS::EC2::VPNConnection, AWS::EC2::VPNGateway, AWS::Route53RecoveryReadiness::DNSTargetResource
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceSet(
        resources: [Resource]? = nil,
        resourceSetName: String,
        resourceSetType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceSetResponse {
        let input = UpdateResourceSetRequest(
            resources: resources, 
            resourceSetName: resourceSetName, 
            resourceSetType: resourceSetType
        )
        return try await self.updateResourceSet(input, logger: logger)
    }
}

extension Route53RecoveryReadiness {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Route53RecoveryReadiness, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Route53RecoveryReadiness {
    /// Return PaginatorSequence for operation ``getCellReadinessSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCellReadinessSummaryPaginator(
        _ input: GetCellReadinessSummaryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCellReadinessSummaryRequest, GetCellReadinessSummaryResponse> {
        return .init(
            input: input,
            command: self.getCellReadinessSummary,
            inputKey: \GetCellReadinessSummaryRequest.nextToken,
            outputKey: \GetCellReadinessSummaryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCellReadinessSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - cellName: The name of the cell.
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCellReadinessSummaryPaginator(
        cellName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCellReadinessSummaryRequest, GetCellReadinessSummaryResponse> {
        let input = GetCellReadinessSummaryRequest(
            cellName: cellName, 
            maxResults: maxResults
        )
        return self.getCellReadinessSummaryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getReadinessCheckResourceStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getReadinessCheckResourceStatusPaginator(
        _ input: GetReadinessCheckResourceStatusRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckResourceStatusRequest, GetReadinessCheckResourceStatusResponse> {
        return .init(
            input: input,
            command: self.getReadinessCheckResourceStatus,
            inputKey: \GetReadinessCheckResourceStatusRequest.nextToken,
            outputKey: \GetReadinessCheckResourceStatusResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getReadinessCheckResourceStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - readinessCheckName: Name of a readiness check.
    ///   - resourceIdentifier: The resource identifier, which is the Amazon Resource Name (ARN) or the identifier generated for the resource by Application Recovery Controller (for example, for a DNS target resource).
    ///   - logger: Logger used for logging
    @inlinable
    public func getReadinessCheckResourceStatusPaginator(
        maxResults: Int? = nil,
        readinessCheckName: String,
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckResourceStatusRequest, GetReadinessCheckResourceStatusResponse> {
        let input = GetReadinessCheckResourceStatusRequest(
            maxResults: maxResults, 
            readinessCheckName: readinessCheckName, 
            resourceIdentifier: resourceIdentifier
        )
        return self.getReadinessCheckResourceStatusPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getReadinessCheckStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getReadinessCheckStatusPaginator(
        _ input: GetReadinessCheckStatusRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckStatusRequest, GetReadinessCheckStatusResponse> {
        return .init(
            input: input,
            command: self.getReadinessCheckStatus,
            inputKey: \GetReadinessCheckStatusRequest.nextToken,
            outputKey: \GetReadinessCheckStatusResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getReadinessCheckStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - readinessCheckName: Name of a readiness check.
    ///   - logger: Logger used for logging
    @inlinable
    public func getReadinessCheckStatusPaginator(
        maxResults: Int? = nil,
        readinessCheckName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckStatusRequest, GetReadinessCheckStatusResponse> {
        let input = GetReadinessCheckStatusRequest(
            maxResults: maxResults, 
            readinessCheckName: readinessCheckName
        )
        return self.getReadinessCheckStatusPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getRecoveryGroupReadinessSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getRecoveryGroupReadinessSummaryPaginator(
        _ input: GetRecoveryGroupReadinessSummaryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetRecoveryGroupReadinessSummaryRequest, GetRecoveryGroupReadinessSummaryResponse> {
        return .init(
            input: input,
            command: self.getRecoveryGroupReadinessSummary,
            inputKey: \GetRecoveryGroupReadinessSummaryRequest.nextToken,
            outputKey: \GetRecoveryGroupReadinessSummaryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getRecoveryGroupReadinessSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - recoveryGroupName: The name of a recovery group.
    ///   - logger: Logger used for logging
    @inlinable
    public func getRecoveryGroupReadinessSummaryPaginator(
        maxResults: Int? = nil,
        recoveryGroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetRecoveryGroupReadinessSummaryRequest, GetRecoveryGroupReadinessSummaryResponse> {
        let input = GetRecoveryGroupReadinessSummaryRequest(
            maxResults: maxResults, 
            recoveryGroupName: recoveryGroupName
        )
        return self.getRecoveryGroupReadinessSummaryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCells(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCellsPaginator(
        _ input: ListCellsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCellsRequest, ListCellsResponse> {
        return .init(
            input: input,
            command: self.listCells,
            inputKey: \ListCellsRequest.nextToken,
            outputKey: \ListCellsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCells(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCellsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCellsRequest, ListCellsResponse> {
        let input = ListCellsRequest(
            maxResults: maxResults
        )
        return self.listCellsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCrossAccountAuthorizations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCrossAccountAuthorizationsPaginator(
        _ input: ListCrossAccountAuthorizationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCrossAccountAuthorizationsRequest, ListCrossAccountAuthorizationsResponse> {
        return .init(
            input: input,
            command: self.listCrossAccountAuthorizations,
            inputKey: \ListCrossAccountAuthorizationsRequest.nextToken,
            outputKey: \ListCrossAccountAuthorizationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCrossAccountAuthorizations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCrossAccountAuthorizationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCrossAccountAuthorizationsRequest, ListCrossAccountAuthorizationsResponse> {
        let input = ListCrossAccountAuthorizationsRequest(
            maxResults: maxResults
        )
        return self.listCrossAccountAuthorizationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReadinessChecks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadinessChecksPaginator(
        _ input: ListReadinessChecksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReadinessChecksRequest, ListReadinessChecksResponse> {
        return .init(
            input: input,
            command: self.listReadinessChecks,
            inputKey: \ListReadinessChecksRequest.nextToken,
            outputKey: \ListReadinessChecksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReadinessChecks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReadinessChecksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReadinessChecksRequest, ListReadinessChecksResponse> {
        let input = ListReadinessChecksRequest(
            maxResults: maxResults
        )
        return self.listReadinessChecksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRecoveryGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRecoveryGroupsPaginator(
        _ input: ListRecoveryGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRecoveryGroupsRequest, ListRecoveryGroupsResponse> {
        return .init(
            input: input,
            command: self.listRecoveryGroups,
            inputKey: \ListRecoveryGroupsRequest.nextToken,
            outputKey: \ListRecoveryGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRecoveryGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRecoveryGroupsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRecoveryGroupsRequest, ListRecoveryGroupsResponse> {
        let input = ListRecoveryGroupsRequest(
            maxResults: maxResults
        )
        return self.listRecoveryGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceSetsPaginator(
        _ input: ListResourceSetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceSetsRequest, ListResourceSetsResponse> {
        return .init(
            input: input,
            command: self.listResourceSets,
            inputKey: \ListResourceSetsRequest.nextToken,
            outputKey: \ListResourceSetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceSets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceSetsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceSetsRequest, ListResourceSetsResponse> {
        let input = ListResourceSetsRequest(
            maxResults: maxResults
        )
        return self.listResourceSetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        _ input: ListRulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        return .init(
            input: input,
            command: self.listRules,
            inputKey: \ListRulesRequest.nextToken,
            outputKey: \ListRulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The number of objects that you want to return with this call.
    ///   - resourceType: The resource type that a readiness rule applies to.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        maxResults: Int? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        let input = ListRulesRequest(
            maxResults: maxResults, 
            resourceType: resourceType
        )
        return self.listRulesPaginator(input, logger: logger)
    }
}

extension Route53RecoveryReadiness.GetCellReadinessSummaryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.GetCellReadinessSummaryRequest {
        return .init(
            cellName: self.cellName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.GetReadinessCheckResourceStatusRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.GetReadinessCheckResourceStatusRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            readinessCheckName: self.readinessCheckName,
            resourceIdentifier: self.resourceIdentifier
        )
    }
}

extension Route53RecoveryReadiness.GetReadinessCheckStatusRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.GetReadinessCheckStatusRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            readinessCheckName: self.readinessCheckName
        )
    }
}

extension Route53RecoveryReadiness.GetRecoveryGroupReadinessSummaryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.GetRecoveryGroupReadinessSummaryRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            recoveryGroupName: self.recoveryGroupName
        )
    }
}

extension Route53RecoveryReadiness.ListCellsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListCellsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.ListCrossAccountAuthorizationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListCrossAccountAuthorizationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.ListReadinessChecksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListReadinessChecksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.ListRecoveryGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListRecoveryGroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.ListResourceSetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListResourceSetsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Route53RecoveryReadiness.ListRulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53RecoveryReadiness.ListRulesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceType: self.resourceType
        )
    }
}
